package test

import (
	"fmt"
	"github.com/beherochuling/beesoft_api/app/helper/archive"
	"github.com/beherochuling/beesoft_api/app/helper/helper"
	"github.com/beherochuling/beesoft_api/app/helper/net"
	"github.com/gogf/gf/v2/frame/g"
	"log"
	"os"

	// "testing"

	// "github.com/gogf/goframe/v2/frame/g"

	// "github.com/gogf/goframe/v2/os/gtime"

	"github.com/gogf/gf/v2/net/ghttp"

	"github.com/gogf/gf/v2/container/garray"
	// "github.com/gogf/goframe/v2/encoding/gjson"
	// "github.com/gogf/goframe/v2/encoding/gurl"
	// "github.com/gogf/goframe/v2/encoding/gcharset"
	// "github.com/gogf/goframe/v2/text/gstr"
	// "github.com/gogf/goframe/v2/text/gregex"
	// "github.com/gogf/goframe/v2/util/gmeta"
	// "github.com/gogf/goframe/v2/util/guid"
	// "github.com/gogf/goframe/v2/test/gtest"
	// _image "github.com/beherochuling/beesoft_api/app/helper/media/image"
)

var Test = &testApi{}

type testApi struct {
}

func (receiver *testApi) TestDownload(r *ghttp.Request) {
	r.Response.ServeFileDownload("test.txt")
}

// 通用控制器方法
func (receiver *testApi) Test01(r *ghttp.Request) {
	// networks, err := docker.Docker.Network.List()
	// if err != nil {
	// 	panic(err)
	// }
	//
	// for _, network := range networks {
	// 	// fmt.Println(network)
	// 	fmt.Println(network.ID, network.Name)
	// }
	//
	//
	// images, err := docker.Docker.Image.List()
	// if err != nil {
	// 	panic(err)
	// }
	//
	// for _, image := range images {
	// 	// fmt.Println(image)
	// 	fmt.Println(image.ID, image.Labels)
	// }
	// // "docker.io/library/alpine"
	//
	//
	// containers, err := docker.Docker.Container.List()
	// if err != nil {
	// 	panic(err)
	// }
	//
	// for _, container := range containers {
	// 	// fmt.Println(container)
	// 	fmt.Println(container.ID, container.Names, container.Image)
	// }
	//
	// containerID := ""
	//
	// containerID, err = docker.Docker.Container.Run(containerID)
	// if err == nil {
	// 	fmt.Println("删除容器", containerID, "成功")
	// }
	//
	// containerID, err = docker.Docker.Container.Run(containerID)
	// if err == nil {
	// 	fmt.Println("删除容器", containerID, "成功")
	// }
	//
	// _, err = docker.Docker.Container.Logs(containerID)
	// if err == nil {
	// 	fmt.Println("日志容器", containerID, "成功")
	// }
	//
	// _, err = docker.Docker.Container.Logs(containerID)
	// if err == nil {
	// 	fmt.Println("日志容器", containerID, "成功")
	// }
	//
	// err = docker.Docker.Container.Start(containerID)
	// if err == nil {
	// 	fmt.Println("启动容器", containerID, "成功")
	// }
	//
	// err = docker.Docker.Container.Stop(containerID)
	// if err == nil {
	// 	fmt.Println("停止容器", containerID, "成功")
	// }
	//
	// err = docker.Docker.Container.Restart(containerID)
	// if err == nil {
	// 	fmt.Println("重启容器", containerID, "成功")
	// }
	//
	// containerID, err = docker.Docker.Container.Remove(containerID)
	// if err == nil {
	// 	fmt.Println("删除容器", containerID, "成功")
	// }

	// ossConfig := g.Cfg().MustGet(r.Context(), "aliyun.oss").MapStrStr()
	// _, err := org.AliyunOss.UploadFile(r.Context(), ossConfig, "28621932-df2b-4baa-a99e-8b9bc8a28cbf.zip", "B:\\data\\downloads\\output\\28621932-df2b-4baa-a99e-8b9bc8a28cbf.zip")
	// if err != nil {
	// 	panic(err)
	// }

	net.NewResponse(r).ResponseOk(g.Map{
		"uri": "uri",
	})
}
func (receiver *testApi) Test02(r *ghttp.Request) {
	// inFile, err := os.Open("B:\\goframe\\productions\\task\\docker\\data\\test\\1.png")
	// if err != nil {
	// 	panic(err)
	// }
	// defer inFile.Close()

	// outFile, err := os.Create("B:\\goframe\\productions\\task\\docker\\data\\test\\2.png")
	// if err != nil {
	// 	panic(err)
	// }
	// defer outFile.Close()

	// reader := exec.ExecWithPipe("C:\\Program Files\\7-Zip\\7z.exe", "a", "B:\\goframe\\productions\\task\\1.7z", "B:\\goframe\\productions\\task\\adm.ini")
	// written, err := io.Copy(outFile, reader)
	// if err != nil {
	// 	panic(err)
	// }
	// fmt.Printf("written: %d", written)

	// exec.ExecWithPipe2()
	// exec.ExecWithPipe3()
}

func (receiver *testApi) TestGjson1(r *ghttp.Request) {
	// jsonContent := `{"name":"john", "score":"100"}`
	// j := gjson.New(jsonContent)
	// fmt.Println(j.Get("name"))
	// fmt.Println(j.Get("score"))

	// jsonContent := `<?xml version="1.0" encoding="UTF-8"?><doc><name>john</name><score>100</score></doc>`
	// j := gjson.New(jsonContent)
	// fmt.Println(j.Get("doc.name"))
	// fmt.Println(j.Get("doc.score"))

	// type Me struct {
	//     Name  string `json:"name"`
	//     Score int    `json:"score"`
	// }
	// me := Me{
	//     Name:  "john",
	//     Score: 100,
	// }
	// j := gjson.New(me)
	// fmt.Println(j.Get("name"))
	// fmt.Println(j.Get("score"))

	// type Me struct {
	//     Name  string `tag:"name"`
	//     Score int    `tag:"score"`
	//     Title string
	// }
	// me := Me{
	//     Name:  "john",
	//     Score: 100,
	//     Title: "engineer",
	// }
	// j := gjson.NewWithTag(me, "tag")
	// fmt.Println(j.Get("name"))
	// fmt.Println(j.Get("score"))
	// fmt.Println(j.Get("Title"))

	// jsonFilePath := gdebug.TestDataPath("json", "data1.json")
	// j, _ := gjson.Load(jsonFilePath)
	// fmt.Println(j.Get("name"))
	// fmt.Println(j.Get("score"))

	// jsonFilePath := gdebug.TestDataPath("json", "data1.xml")
	// j, _ := gjson.Load(jsonFilePath)
	// fmt.Println(j.Get("doc.name"))
	// fmt.Println(j.Get("doc.score"))

	// jsonContent := `{"name":"john", "score":"100"}`
	// j, _ := gjson.LoadContent(jsonContent)
	// fmt.Println(j.Get("name"))
	// fmt.Println(j.Get("score"))

	// data := `{
	//     "users" : {
	//         "count" : 2,
	//         "list"  : [
	//             {"name" : "Ming", "score" : 60},
	//             {"name" : "John", "score" : 99.5}
	//         ]
	//     }
	// }`
	// if j, err := gjson.DecodeToJson(data); err != nil {
	//     panic(err)
	// } else {
	//     fmt.Println("John Score:", j.GetFloat32("users.list.1.score"))
	// }

	// data := `{
	//     "users" : {
	//         "count" : 2,
	//         "list"  : [
	//             {"name" : "Ming", "score" : 60},
	//             {"name" : "John", "score" : 99.5}
	//         ]
	//     }
	// }`
	// if j, err := gjson.DecodeToJson(data); err != nil {
	//     panic(err)
	// } else {
	//     j.SetSplitChar('#')
	//     fmt.Println("John Score:", j.GetFloat32("users#list#1#score"))
	// }

	// data := `{
	//         "users" : {
	//             "count" : 100
	//         },
	//         "users.count" : 101
	//     }`
	// if j, err := gjson.DecodeToJson(data); err != nil {
	//     glog.Error(err)
	// } else {
	//     j.SetViolenceCheck(true)
	//     fmt.Println("Users Count:", j.GetInt("users.count"))
	// }

	// jsonContent := `{"map":{"key":"value"}, "slice":[59,90]}`
	// j, _ := gjson.LoadJson(jsonContent)
	// m := j.GetMap("map")
	// fmt.Println(m)

	// m["key"] = "john"
	// fmt.Println(j.GetMap("map"))

	// s := j.GetArray("slice")
	// fmt.Println(s)

	// s[0] = 100
	// fmt.Println(j.GetArray("slice"))
}
func (receiver *testApi) TestGjson2(r *ghttp.Request) {
	// data := `{
	//     "count" : 1,
	//     "array" : ["John", "Ming"]
	// }`
	// if j, err := gjson.DecodeToJson(data); err != nil {
	//     panic(err)
	// } else {
	//     type Users struct {
	//         Count int
	//         Array []string
	//     }
	//     users := new(Users)
	//     if err := j.Struct(users); err != nil {
	//         panic(err)
	//     }
	//     fmt.Printf(`%+v`, users)
	// }

	// data := `{
	//     "users" : {
	//         "count" : 1,
	//         "array" : ["John", "Ming"]
	//     }
	// }`
	// if j, err := gjson.DecodeToJson(data); err != nil {
	//     panic(err)
	// } else {
	//     type Users struct {
	//         Count int
	//         Array []string
	//     }
	//     users := new(Users)
	//     if err := j.GetStruct("users", users); err != nil {
	//         panic(err)
	//     }
	//     fmt.Printf(`%+v`, users)
	// }

	// j := gjson.New(nil)
	// j.Set("name", "John")
	// j.Set("score", 99.5)
	// fmt.Printf(
	//     "Name: %s, Score: %v\n",
	//     j.GetString("name"),
	//     j.GetFloat32("score"),
	// )
	// fmt.Println(j.MustToJsonString())

	// j := gjson.New(nil)
	// for i := 0; i < 5; i++ {
	//     j.Set(fmt.Sprintf(`%d.id`, i), i)
	//     j.Set(fmt.Sprintf(`%d.name`, i), fmt.Sprintf(`student-%d`, i))
	// }
	// fmt.Println(j.MustToJsonString())

	// data := `{
	//     "users" : {
	//         "count" : 2,
	//         "list"  : [
	//             {"name" : "Ming", "score" : 60},
	//             {"name" : "John", "score" : 59}
	//         ]
	//     }
	// }`
	// if j, err := gjson.DecodeToJson(data); err != nil {
	//     panic(err)
	// } else {
	//     j.Set("users.list.1.score", 100)
	//     fmt.Println("John Score:", j.GetFloat32("users.list.1.score"))
	//     fmt.Println(j.MustToJsonString())
	// }

	// data := `{
	//     "users" : {
	//         "count" : 1,
	//         "array" : ["John", "Ming"]
	//     }
	// }`
	// if j, err := gjson.DecodeToJson(data); err != nil {
	//     panic(err)
	// } else {
	//     fmt.Println(j.MustToJsonString())
	//     fmt.Println(j.MustToXmlString())
	//     fmt.Println(j.MustToYamlString())
	//     fmt.Println(j.MustToTomlString())
	// }
}
func (receiver *testApi) TestGparse1(r *ghttp.Request) {
	// data := `{
	//        "users" : {
	//            "count" : 100,
	//            "list"  : [
	//                {"name" : "Ming", "score" : 60},
	//                {"name" : "John", "score" : 99.5}
	//            ]
	//        }
	//    }`

	// if p, e := gparser.LoadContent([]byte(data), true); e != nil {
	//     glog.Error(e)
	// } else {
	//     fmt.Println("John Score:", p.GetFloat32("users.list.1.score"))
	// }

	// data := `<?xml version="1.0" encoding="UTF-8"?>
	// <note>
	//     <to>Tove</to>
	//     <from>Jani</from>
	//     <heading>Reminder</heading>
	//     <body>Don't forget me this weekend!</body>
	// </note>`

	// if p, e := gparser.LoadContent([]byte(data), true); e != nil {
	//     glog.Error(e)
	// } else {
	//     fmt.Println("Heading:", p.GetString("note.heading"))
	// }

	// data := `{
	//         "users" : {
	//             "count" : 100
	//         },
	//         "users.count" : 101
	//     }`
	// if p, e := gparser.LoadContent([]byte(data), true); e != nil {
	//     glog.Error(e)
	// } else {
	//     p.SetViolenceCheck(true)
	//     fmt.Println("Users Count:", p.Get("users.count"))
	// }

	// data := `{
	//         "users" : {
	//             "count" : {
	//                 "type1" : 1,
	//                 "type2" : 2
	//             },
	//             "count.type1" : 100
	//         }
	//     }`
	// if p, e := gparser.LoadContent([]byte(data), true); e != nil {
	//     glog.Error(e)
	// } else {
	//     p.SetViolenceCheck(true)
	//     fmt.Println("Users Count:", p.Get("users.count.type1"))
	//     fmt.Println("Users Count:", p.Get("users.count.type2"))
	// }

	// data := `{
	//        "users" : {
	//            "count" : 100
	//        }
	//    }`
	// if p, e := gparser.LoadContent([]byte(data), true); e != nil {
	//     glog.Error(e)
	// } else {
	//     p.Set("users.count",  2)
	//     p.Set("users.list",  []string{"John", "小明"})
	//     c, _ := p.ToJson()
	//     fmt.Println(string(c))
	// }

	// data := `<?xml version="1.0" encoding="UTF-8"?>
	//      <article>
	//          <count>10</count>
	//          <list><title>goframe article1</title><content>goframe content1</content></list>
	//          <list><title>goframe article2</title><content>goframe content2</content></list>
	//          <list><title>goframe article3</title><content>goframe content3</content></list>
	//      </article>`
	// if p, e := gparser.LoadContent([]byte(data), true); e != nil {
	//     glog.Error(e)
	// } else {
	//     p.Remove("article.list.0")
	//     c, _ := p.ToJson()
	//     fmt.Println(string(c))
	// }

	// p := gparser.New(nil)
	// p.Set("name",   "john")
	// p.Set("age",    18)
	// p.Set("scores", map[string]int{
	//     "语文" : 100,
	//     "数学" : 100,
	//     "英语" : 100,
	// })
	// c, _ := p.ToXmlIndent("simple-xml")
	// fmt.Println(string(c))

	// type Order struct {
	//     Id    int      `json:"id"`
	//     Price float32  `json:"price"`
	// }
	// p := gparser.New(nil)
	// p.Set("orders.list.0", Order{1, 100})
	// p.Set("orders.list.1", Order{2, 666})
	// p.Set("orders.list.2", Order{3, 999.99})
	// fmt.Println("Order 1 Price:", p.Get("orders.list.1.price"))
	// c, _ := p.ToJson()
	// fmt.Println(string(c))

	// type Info struct {
	//     Name string
	//     Url  string
	// }
	// o := Info{}
	// p := gparser.New(map[string]string {
	//     "Name" : "goframe",
	//     "Url"  : "https://gitee.com/johng",
	// })
	// p.ToStruct(&o)
	// fmt.Println("Name:", o.Name)
	// fmt.Println("Url :", o.Url)

	// p := gparser.New(map[string]string{
	//     "name" : "goframe",
	//     "site" : "https://gitee.com/johng",
	// })

	// c, _ := p.ToJson()
	// fmt.Println(string(c))

	// c, _ = p.ToXmlIndent()
	// fmt.Println(string(c))

	// c, _ = p.ToYaml()
	// fmt.Println(string(c))

	// c, _ = p.ToToml()
	// fmt.Println(string(c))
}
func (receiver *testApi) TestGtime1(r *ghttp.Request) {
	// gtime.New("2020-10-24 12:00:00")
	// gtime.New(time.Now())
	// gtime.New(1603710586)
	// gtime.New(1603710586660409000)

	// formats := []string{
	//     "Y-m-d H:i:s.u",
	//     "D M d H:i:s T O Y",
	//     "\\T\\i\\m\\e \\i\\s: h:i:s a",
	//     "2006-01-02T15:04:05.000000000Z07:00",
	// }
	// t := gtime.Now()
	// for _, f := range formats {
	//     fmt.Println(t.Format(f))
	// }

	// formats := []string{
	//     "2006-01-02 15:04:05.000",
	//     "Mon Jan _2 15:04:05 MST 2006",
	//     "Time is: 03:04:05 PM",
	//     "2006-01-02T15:04:05.000000000Z07:00 MST",
	// }
	// t := gtime.Now()
	// for _, f := range formats {
	//     fmt.Println(t.Layout(f))
	// }

	// fmt.Println(gtime.Now().AddDate(-1, 0, 0).Format("Y-m-d"))
	// fmt.Println(gtime.Now().AddDate(-1, 0, 0).Format("Y-m-d H:i:s T"))
	// fmt.Println(gtime.Now().AddDate(-1, 0, 0).UTC().Format("Y-m-d H:i:s T"))
	// fmt.Println(gtime.Now().AddDate(0, 1, 0).Format("Y-m-d 00:00:00"))
	// fmt.Println(gtime.Now().Add(-time.Hour).Format("Y-m-d H:i:s"))
}
func (receiver *testApi) TestGbinary1(r *ghttp.Request) {
	// if buffer := gbinary.Encode(18, 300, 1.01); buffer != nil {
	//    // glog.Error(err)
	// } else {
	//     fmt.Println(buffer)
	// }

	// if buffer := gbinary.Encode(18, 300, 1.01); buffer != nil {
	//     //glog.Error(err)
	// } else {
	//     var i1 int8
	//     var i2 int16
	//     var f3 float64
	//     if err := gbinary.Decode(buffer, &i1, &i2, &f3); err != nil {
	//         glog.Error(err)
	//     } else {
	//         fmt.Println(i1, i2, f3)
	//     }
	// }

	// // 编码/解析 int，自动识别变量长度
	// fmt.Println(gbinary.DecodeToInt(gbinary.EncodeInt(1)))
	// fmt.Println(gbinary.DecodeToInt(gbinary.EncodeInt(300)))
	// fmt.Println(gbinary.DecodeToInt(gbinary.EncodeInt(70000)))
	// fmt.Println(gbinary.DecodeToInt(gbinary.EncodeInt(2000000000)))
	// fmt.Println(gbinary.DecodeToInt(gbinary.EncodeInt(500000000000)))

	// // 编码/解析 uint，自动识别变量长度
	// fmt.Println(gbinary.DecodeToUint(gbinary.EncodeUint(1)))
	// fmt.Println(gbinary.DecodeToUint(gbinary.EncodeUint(300)))
	// fmt.Println(gbinary.DecodeToUint(gbinary.EncodeUint(70000)))
	// fmt.Println(gbinary.DecodeToUint(gbinary.EncodeUint(2000000000)))
	// fmt.Println(gbinary.DecodeToUint(gbinary.EncodeUint(500000000000)))

	// // 编码/解析 int8/16/32/64
	// fmt.Println(gbinary.DecodeToInt8(gbinary.EncodeInt8(int8(100))))
	// fmt.Println(gbinary.DecodeToInt16(gbinary.EncodeInt16(int16(100))))
	// fmt.Println(gbinary.DecodeToInt32(gbinary.EncodeInt32(int32(100))))
	// fmt.Println(gbinary.DecodeToInt64(gbinary.EncodeInt64(int64(100))))

	// // 编码/解析 uint8/16/32/64
	// fmt.Println(gbinary.DecodeToUint8(gbinary.EncodeUint8(uint8(100))))
	// fmt.Println(gbinary.DecodeToUint16(gbinary.EncodeUint16(uint16(100))))
	// fmt.Println(gbinary.DecodeToUint32(gbinary.EncodeUint32(uint32(100))))
	// fmt.Println(gbinary.DecodeToUint64(gbinary.EncodeUint64(uint64(100))))

	// // 编码/解析 string
	// fmt.Println(gbinary.DecodeToString(gbinary.EncodeString("I'm string!")))

	// count  := 100
	// status := 1

	// bits := make([]gbinary.Bit, 0)
	// for i := 0; i < count; i++ {
	//     bits = gbinary.EncodeBits(bits, int(status), 2)
	// }
	// buffer := gbinary.EncodeBitsToBytes(bits)
	// fmt.Println("buffer length:", len(buffer))

	// alivecount := 0
	// sensorbits := gbinary.DecodeBytesToBits(buffer)
	// for i := 0; i < len(sensorbits); i += 2 {
	//     if gbinary.DecodeBits(sensorbits[i:i+2]) == 1 {
	//         alivecount++
	//     }
	// }
	// fmt.Println("alived sensor:", alivecount)

	// hash   := 521369841259754125
	// klen   := 12
	// vlen   := 35535
	// offset := 80000000

	// bits   := make([]gbinary.Bit, 0)
	// bits    = gbinary.EncodeBits(bits, hash,   64)
	// bits    = gbinary.EncodeBits(bits, klen,    8)
	// bits    = gbinary.EncodeBits(bits, vlen,   24)
	// bits    = gbinary.EncodeBits(bits, offset, 40)
	// buffer := gbinary.EncodeBitsToBytes(bits)
	// fmt.Println("meta length:", len(buffer))

	// metabits := gbinary.DecodeBytesToBits(buffer)
	// fmt.Println("hash  :", gbinary.DecodeBits(metabits[0  : 64]))
	// fmt.Println("klen  :", gbinary.DecodeBits(metabits[64 : 72]))
	// fmt.Println("vlen  :", gbinary.DecodeBits(metabits[72 : 96]))
	// fmt.Println("offset:", gbinary.DecodeBits(metabits[96 : 136]))
}
func (receiver *testApi) TestGurl1(r *ghttp.Request) {
	// values := url.Values{}
	// values.Add("name", "gopher")
	// values.Add("limit", "20")
	// values.Add("page", "7")

	// urlStr := gurl.BuildQuery(values)
	// fmt.Println(urlStr)

	// encodeStr := gurl.Encode("limit=20&name=gopher&page=7")
	// fmt.Println(encodeStr)

	// decodeStr, err := gurl.Decode("limit%3D20%26name%3Dgopher%26page%3D7")
	// if err != nil {
	// 	log.Fatal(err)
	// }
	// fmt.Println(decodeStr)

	// data, err := gurl.ParseURL("http://127.0.0.1:8199/goods?limit=20&name=gopher&page=7", -1)
	// if err != nil {
	// 	log.Fatal(err)
	// }
	// fmt.Println(data)
	// fmt.Println(data["host"])
	// fmt.Println(data["query"])
	// fmt.Println(data["path"])
	// fmt.Println(data["scheme"])
	// fmt.Println(data["fragment"])
}
func (receiver *testApi) TestGcharset1(r *ghttp.Request) {
	// src        := "~{;(<dR;:x>F#,6@WCN^O`GW!#"
	// srcCharset := "GB2312"
	// dstCharset := "UTF-8"
	// str, err := gcharset.Convert(dstCharset, srcCharset, src)
	// if err != nil {
	// 	panic(err)
	// }
	// fmt.Println(str)
}
func (receiver *testApi) TestGregex1(r *ghttp.Request) {
	// match, _ := gregex.MatchString(`(\w+).+\-\-\s*(.+)`, `GF is best! -- John`)
	// fmt.Printf(`%s says "%s" is the one he loves!`, match[2], match[1])
}
func (receiver *testApi) TestGmeta1(r *ghttp.Request) {
	// type User struct {
	// 	gmeta.Meta `orm:"user" db:"mysql"`
	// 	Id         int
	// 	Name       string
	// }
	// g.Dump(gmeta.Data(User{}))

	// type User struct {
	// 	gmeta.Meta `orm:"user" db:"mysql"`
	// 	Id         int
	// 	Name       string
	// }
	// user := User{}
	// fmt.Println(gmeta.Get(user, "orm").String())
	// fmt.Println(gmeta.Get(user, "db").String())
}
func (receiver *testApi) TestGregexxx1(r *ghttp.Request) {
	// fmt.Printf("TraceId: %s", guid.S())

	//    var (
	//        address = request.RemoteAddr
	//        header  = fmt.Sprintf("%v", request.Header)
	//    )
	//    return guid.S([]byte(address), []byte(header))
}
func (receiver *testApi) TestGtest1(r *ghttp.Request) {
	// gtest.C(t, func(t *gtest.T) {
	//     t.Assert(gstr.Trim(" 123456\n "),      "123456")
	//     t.Assert(gstr.Trim("#123456#;", "#;"), "123456")
	// })

	// C(t, func() {
	//     Assert(gstr.Trim(" 123456\n "),      "123456")
	//     Assert(gstr.Trim("#123456#;", "#;"), "123456")
	// })
}
func (receiver *testApi) TestConvert1(r *ghttp.Request) {
	// a, _ := strconv.Itoa(100) // 整形 => 字符串
	// i, _ := strconv.Atoi("100") // 字符串 => 整形
	// a, _ := strconv.FormatInt(0x100, 10) // 64位整形 => 字符串

	// bytesBuffer := bytes.NewBuffer([]byte{0x00, 0x00, 0x03, 0xe8}) // 字节 => 32位整形
	// var x int32
	// binary.Read(bytesBuffer, binary.BigEndian, &x)

	// bytesBuffer := bytes.NewBuffer([]byte{}) // 32位整形 => 字节
	// binary.Write(bytesBuffer, binary.BigEndian, 106)
	// bytesBuffer.Bytes()

	// string([]byte{97, 98, 99, 100}) // 字节 => 字符串
	// []byte("abcd") // 字符串 => 字节
}

func (receiver *testApi) TestGArray1(r *ghttp.Request) {
	a := garray.NewIntArray(true)

	for i := 0; i < 10; i++ {
		a.Append(i)
	}

	fmt.Println(a.Len())
	fmt.Println(a.Slice())
	fmt.Println(a.Get(6))
	fmt.Println(a.Search(5))

	a.InsertAfter(9, 11)
	a.InsertBefore(10, 10)
	a.Set(0, 100)
	a.Remove(0)
	a.LockFunc(func(array []int) {
		array[len(array)-1] = 100
	})
	a.RLockFunc(func(array []int) {
		fmt.Println(array[len(array)-1])
	})
	a.Clear()
}

func (receiver *testApi) TestImage(r *ghttp.Request) {
	// reader, err := os.Open("image.png")
	// if err != nil {
	// 	log.Fatal(err)
	// }
	// defer reader.Close()
	//
	// writer, err := os.Create("image.jpg")
	// if err != nil {
	// 	log.Fatal(err)
	// }
	// defer writer.Close()

	fileio, err := os.OpenFile("image.png", os.O_RDWR, 0)
	if err != nil {
		log.Fatal(err)
	}
	defer fileio.Close()

	// _image.Image.SetType("jpeg").
	// 	SetQuality(50).
	// 	Compress(fileio, fileio)
	// _image.Image.Convert(reader, writer)
}
func (receiver *testApi) TestArchive(r *ghttp.Request) {
	// var reader bytes.Buffer
	// var writer bytes.Buffer
	reader, err := os.Open("C:/2.tar")
	if err != nil {
		helper.Log("Error", "open file error")
	}
	defer reader.Close()
	// writer, err := os.Create("C:/2.tar")
	// if err != nil {
	// 	helper.Log("Error", "create file error")
	// }
	// defer writer.Close()
	//
	// var files = []archive.File{
	// 	{"readme.txt", "This archive contains some text files."},
	// 	{"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"},
	// 	{"todo.txt", "Get animal handling license."},
	// }
	//
	// archive.Tar.Writer(writer, files)

	files, err := archive.Tar.Reader(reader)
	if err != nil {
		helper.Log("Error", "Error")
	}
	for _, file := range files {
		fmt.Println(file.Name)
		fmt.Println(file.Body)
	}

	// for _, file := range files {
	// f, err := writer.Create(file.Name)
	// _, err = f.Write([]byte(file.Body))
	// if err != nil {
	// 	panic(err)
	// }
	// }

}
